/*******************************************************************************
**                      Includes                                              **
*******************************************************************************/
#include "StandardTypes.h"
#include "TestCase.h"
#include "sm2.h"
#include "Csm.h"
#include "Crypto_Types.h"
#include "SchM_Csm.h"
#include "SchM_Crypto.h"

/*******************************************************************************
**                      Static Macro Definitions                             **
*******************************************************************************/
// UserID
const uint8 User_Id[] = {'1','2','3','4','5','6','7','8','1','2','3','4','5','6','7','8'};
uint32 User_Len = sizeof(User_Id);

#if(TESTCASE == 1)
//Message
const uint8 TestCase1_Message[] = {
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
};

// PublicKey
static const uint8 TestCase1_PublicKey[64] = {0x50, 0xE2, 0x78, 0xAB, 0xBA, 0xB4, 0x5C, 0xA2, 0xE8, 0x13, 0x41, 0x99, 0xE0, 0xED, 0xE0, 0xCA,
                        0xA6, 0x94, 0xD3, 0xDE, 0x26, 0xC9, 0xFC, 0xEF, 0xFC, 0xDF, 0xEE, 0xDC, 0x85, 0x92, 0xCC, 0x9D,
                        0x4E, 0x6E, 0xDE, 0x36, 0x2A, 0x2C, 0x62, 0x47, 0xA1, 0x56, 0x33, 0x63, 0x84, 0xDC, 0x9C, 0x09,
                        0xE3, 0x6B, 0x14, 0xB5, 0x63, 0x9B, 0xEB, 0xDD, 0x1B, 0x99, 0xC9, 0x2A, 0x4E, 0x46, 0x44, 0xCD,};
// PrivateKey
static const uint8 TestCase1_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                        0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase1_MixData[1500] = {0u};
uint32 TestCase1_MessageLen = sizeof(TestCase1_Message);
uint8 TestCase1_MixSignature[64] = {0u};
uint8 TestCase1_SignatureZero[64] = {0u};
uint32 TestCase1_SignatureLen = 0u;
Crypto_VerifyResultType TestCase1_VerifyResult = 1u;
uint8 TestCase1_MessageLenTemp[4] = {0u};
uint8 TestCase1_UserIDLenTemp[4] = {0u};
#endif

#if(TESTCASE == 2)
//Message
const uint8 TestCase2_Message[] = {
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
};

// PublicKey
static const uint8 TestCase2_PublicKey[64] = {0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44,
                                                0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44,
                                                0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44,
                                                0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44, 0x11, 0x22, 0x33, 0x44,};
// PrivateKey
static const uint8 TestCase2_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                                                0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase2_MixData[1500] = {0u};
uint32 TestCase2_MessageLen = sizeof(TestCase2_Message);
uint8 TestCase2_MixSignature[64] = {0u};
uint8 TestCase2_SignatureZero[64] = {0u};
uint32 TestCase2_SignatureLen = 0u;
Crypto_VerifyResultType TestCase2_VerifyResult = 1u;
uint8 TestCase2_MessageLenTemp[4] = {0u};
uint8 TestCase2_UserIDLenTemp[4] = {0u};
#endif

#if(TESTCASE == 3)
//Message
const uint8 TestCase3_Message[] = {
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
};

// PublicKey
static const uint8 TestCase3_PublicKey[64] = {0x50, 0xE2, 0x78, 0xAB, 0xBA, 0xB4, 0x5C, 0xA2, 0xE8, 0x13, 0x41, 0x99, 0xE0, 0xED, 0xE0, 0xCA,
                                                0xA6, 0x94, 0xD3, 0xDE, 0x26, 0xC9, 0xFC, 0xEF, 0xFC, 0xDF, 0xEE, 0xDC, 0x85, 0x92, 0xCC, 0x9D,
                                                0x4E, 0x6E, 0xDE, 0x36, 0x2A, 0x2C, 0x62, 0x47, 0xA1, 0x56, 0x33, 0x63, 0x84, 0xDC, 0x9C, 0x09,
                                                0xE3, 0x6B, 0x14, 0xB5, 0x63, 0x9B, 0xEB, 0xDD, 0x1B, 0x99, 0xC9, 0x2A, 0x4E, 0x46, 0x44, 0xCD,};
// PrivateKey
static const uint8 TestCase3_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                                                0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase3_MixData[1500] = {0u};
uint32 TestCase3_MessageLen = sizeof(TestCase3_Message);
uint8 TestCase3_MixSignature[64] = {0u};
uint8 TestCase3_SignatureZero[64] = {0u};
uint32 TestCase3_SignatureLen = 0u;
Crypto_VerifyResultType TestCase3_VerifyResult = 1u;
uint8 TestCase3_MessageLenTemp[4] = {0u};
uint8 TestCase3_UserIDLenTemp[4] = {0u};
#endif

#if(TESTCASE == 4)
//Message
const uint8 TestCase4_Message[] = {""};

// PublicKey
static const uint8 TestCase4_PublicKey[64] = {0x50, 0xE2, 0x78, 0xAB, 0xBA, 0xB4, 0x5C, 0xA2, 0xE8, 0x13, 0x41, 0x99, 0xE0, 0xED, 0xE0, 0xCA,
                                                0xA6, 0x94, 0xD3, 0xDE, 0x26, 0xC9, 0xFC, 0xEF, 0xFC, 0xDF, 0xEE, 0xDC, 0x85, 0x92, 0xCC, 0x9D,
                                                0x4E, 0x6E, 0xDE, 0x36, 0x2A, 0x2C, 0x62, 0x47, 0xA1, 0x56, 0x33, 0x63, 0x84, 0xDC, 0x9C, 0x09,
                                                0xE3, 0x6B, 0x14, 0xB5, 0x63, 0x9B, 0xEB, 0xDD, 0x1B, 0x99, 0xC9, 0x2A, 0x4E, 0x46, 0x44, 0xCD,};
// PrivateKey
static const uint8 TestCase4_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                                                0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase4_MixData[1500] = {0u};
uint32 TestCase4_MessageLen = sizeof(TestCase4_Message);
uint8 TestCase4_MixSignature[64] = {0u};
uint8 TestCase4_SignatureZero[64] = {0u};
uint32 TestCase4_SignatureLen = 0u;
Crypto_VerifyResultType TestCase4_VerifyResult = 1u;
uint8 TestCase4_MessageLenTemp[4] = {0u};
uint8 TestCase4_UserIDLenTemp[4] = {0u};
#endif

#if(TESTCASE == 5)
//Message
const uint8 TestCase5_Message[] = {0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,};

// PublicKey
static const uint8 TestCase5_PublicKey[64] = {0x50, 0xE2, 0x78, 0xAB, 0xBA, 0xB4, 0x5C, 0xA2, 0xE8, 0x13, 0x41, 0x99, 0xE0, 0xED, 0xE0, 0xCA,
                                                0xA6, 0x94, 0xD3, 0xDE, 0x26, 0xC9, 0xFC, 0xEF, 0xFC, 0xDF, 0xEE, 0xDC, 0x85, 0x92, 0xCC, 0x9D,
                                                0x4E, 0x6E, 0xDE, 0x36, 0x2A, 0x2C, 0x62, 0x47, 0xA1, 0x56, 0x33, 0x63, 0x84, 0xDC, 0x9C, 0x09,
                                                0xE3, 0x6B, 0x14, 0xB5, 0x63, 0x9B, 0xEB, 0xDD, 0x1B, 0x99, 0xC9, 0x2A, 0x4E, 0x46, 0x44, 0xCD,};
// PrivateKey
static const uint8 TestCase5_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                                                0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase5_MixData[1500] = {0u};
uint32 TestCase5_MessageLen = sizeof(TestCase5_Message);
uint8 TestCase5_MixSignature[64] = {0u};
uint8 TestCase5_SignatureZero[64] = {0u};
uint32 TestCase5_SignatureLen = 0u;
Crypto_VerifyResultType TestCase5_VerifyResult = 1u;
uint8 TestCase5_MessageLenTemp[4] = {0u};
uint8 TestCase5_UserIDLenTemp[4] = {0u};
#endif

#if(TESTCASE == 6)

#endif

#if(TESTCASE == 7)

#endif

#if(TESTCASE == 8)

#endif

#if(TESTCASE == 9)
//Message
const uint8 TestCase9_Message[] = {
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
};
// PublicKey
static const uint8 TestCase9_PublicKey[64] = {0x50, 0xE2, 0x78, 0xAB, 0xBA, 0xB4, 0x5C, 0xA2, 0xE8, 0x13, 0x41, 0x99, 0xE0, 0xED, 0xE0, 0xCA,
                                                0xA6, 0x94, 0xD3, 0xDE, 0x26, 0xC9, 0xFC, 0xEF, 0xFC, 0xDF, 0xEE, 0xDC, 0x85, 0x92, 0xCC, 0x9D,
                                                0x4E, 0x6E, 0xDE, 0x36, 0x2A, 0x2C, 0x62, 0x47, 0xA1, 0x56, 0x33, 0x63, 0x84, 0xDC, 0x9C, 0x09,
                                                0xE3, 0x6B, 0x14, 0xB5, 0x63, 0x9B, 0xEB, 0xDD, 0x1B, 0x99, 0xC9, 0x2A, 0x4E, 0x46, 0x44, 0xCD,};
// PrivateKey
static const uint8 TestCase9_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                                                0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase9_MixData[1500] = {0u};
uint32 TestCase9_MessageLen = sizeof(TestCase9_Message);
uint8 TestCase9_MixSignatureA[64] = {0u};
uint8 TestCase9_MixSignatureB[64] = {0u};
uint8 TestCase9_MixSignatureC[64] = {0u};
uint32 TestCase9_SignatureLenA = 0u;
uint32 TestCase9_SignatureLenB = 0u;
uint32 TestCase9_SignatureLenC = 0u;
uint8 TestCase9_SignatureZero[64] = {0u};
Crypto_VerifyResultType TestCase9_VerifyResult = 1u;
uint8 TestCase9_MessageLenTemp[4] = {0u};
uint8 TestCase9_UserIDLenTemp[4] = {0u};

uint8 StatusCtl = 0u;

#endif

#if(TESTCASE == 10)
//Message
const uint8 TestCase10_Message[] = {
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
};

// PublicKey
static const uint8 TestCase10_PublicKey[64] = {0x50, 0xE2, 0x78, 0xAB, 0xBA, 0xB4, 0x5C, 0xA2, 0xE8, 0x13, 0x41, 0x99, 0xE0, 0xED, 0xE0, 0xCA,
                        0xA6, 0x94, 0xD3, 0xDE, 0x26, 0xC9, 0xFC, 0xEF, 0xFC, 0xDF, 0xEE, 0xDC, 0x85, 0x92, 0xCC, 0x9D,
                        0x4E, 0x6E, 0xDE, 0x36, 0x2A, 0x2C, 0x62, 0x47, 0xA1, 0x56, 0x33, 0x63, 0x84, 0xDC, 0x9C, 0x09,
                        0xE3, 0x6B, 0x14, 0xB5, 0x63, 0x9B, 0xEB, 0xDD, 0x1B, 0x99, 0xC9, 0x2A, 0x4E, 0x46, 0x44, 0xCD,};
// PrivateKey
static const uint8 TestCase10_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                        0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase10_MixData[1500] = {0u};
uint32 TestCase10_MessageLen = sizeof(TestCase10_Message);
uint8 TestCase10_MixSignature[64] = {0u};
uint8 TestCase10_SignatureZero[64] = {0u};
uint32 TestCase10_SignatureLen = 0u;
Crypto_VerifyResultType TestCase10_VerifyResultA = 1u;
Crypto_VerifyResultType TestCase10_VerifyResultB = 1u;
Crypto_VerifyResultType TestCase10_VerifyResultC = 1u;
uint8 TestCase10_MessageLenTemp[4] = {0u};
uint8 TestCase10_UserIDLenTemp[4] = {0u};

uint8 StatusCtl = 0u;

#endif

#if(TESTCASE == 11)
//Message
const uint8 TestCase11_Message[] = {
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
};

// PublicKey
static const uint8 TestCase11_PublicKey[64] = {0x50, 0xE2, 0x78, 0xAB, 0xBA, 0xB4, 0x5C, 0xA2, 0xE8, 0x13, 0x41, 0x99, 0xE0, 0xED, 0xE0, 0xCA,
                        0xA6, 0x94, 0xD3, 0xDE, 0x26, 0xC9, 0xFC, 0xEF, 0xFC, 0xDF, 0xEE, 0xDC, 0x85, 0x92, 0xCC, 0x9D,
                        0x4E, 0x6E, 0xDE, 0x36, 0x2A, 0x2C, 0x62, 0x47, 0xA1, 0x56, 0x33, 0x63, 0x84, 0xDC, 0x9C, 0x09,
                        0xE3, 0x6B, 0x14, 0xB5, 0x63, 0x9B, 0xEB, 0xDD, 0x1B, 0x99, 0xC9, 0x2A, 0x4E, 0x46, 0x44, 0xCD,};
// PrivateKey
static const uint8 TestCase11_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                        0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase11_MixData[1500] = {0u};
uint32 TestCase11_MessageLen = sizeof(TestCase11_Message);
uint8 TestCase11_MixSignature[64] = {0u};
uint8 TestCase11_SignatureZero[64] = {0u};
uint32 TestCase11_SignatureLen = 0u;
Crypto_VerifyResultType TestCase11_VerifyResult = 1u;
uint8 TestCase11_MessageLenTemp[4] = {0u};
uint8 TestCase11_UserIDLenTemp[4] = {0u};
#endif

#if(TESTCASE == 12)
//Message
const uint8 TestCase12_Message[] = {
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
};

// PublicKey
static const uint8 TestCase12_PublicKey[64] = {0x50, 0xE2, 0x78, 0xAB, 0xBA, 0xB4, 0x5C, 0xA2, 0xE8, 0x13, 0x41, 0x99, 0xE0, 0xED, 0xE0, 0xCA,
                        0xA6, 0x94, 0xD3, 0xDE, 0x26, 0xC9, 0xFC, 0xEF, 0xFC, 0xDF, 0xEE, 0xDC, 0x85, 0x92, 0xCC, 0x9D,
                        0x4E, 0x6E, 0xDE, 0x36, 0x2A, 0x2C, 0x62, 0x47, 0xA1, 0x56, 0x33, 0x63, 0x84, 0xDC, 0x9C, 0x09,
                        0xE3, 0x6B, 0x14, 0xB5, 0x63, 0x9B, 0xEB, 0xDD, 0x1B, 0x99, 0xC9, 0x2A, 0x4E, 0x46, 0x44, 0xCD,};
// PrivateKey
static const uint8 TestCase12_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                        0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase12_MixData[1500] = {0u};
uint32 TestCase12_MessageLen = sizeof(TestCase12_Message);
uint8 TestCase12_MixSignature[64] = {0x3a, 0x20, 0xe5, 0x91, 0x75, 0x0b, 0x60, 0x96, 0x27, 0xbf, 0x4b, 0x6c, 0xec, 0x56, 0xdf, 0xb3,
                                        0x61, 0x22, 0x85, 0x42, 0x82, 0xc6, 0xbb, 0xee, 0x01, 0xbc, 0x16, 0x20, 0xc6, 0xfa, 0xd2, 0x1c,
                                        0x82, 0x5a, 0x64, 0x47, 0x04, 0x97, 0x9a, 0x76, 0x32, 0x60, 0x16, 0x38, 0xc3, 0xb0, 0x88, 0x1c,
                                        0x8c, 0xf8, 0x16, 0xbc, 0x59, 0x5d, 0x20, 0x74, 0xd1, 0x86, 0xc0, 0x8a, 0x59, 0xf9, 0x7a, 0x2d,};
uint8 TestCase12_SignatureZero[64] = {0u};
uint32 TestCase12_SignatureLen = 0u;
Crypto_VerifyResultType TestCase12_VerifyResult = 1u;
uint8 TestCase12_MessageLenTemp[4] = {0u};
uint8 TestCase12_UserIDLenTemp[4] = {0u};
#endif

#if(TESTCASE == 13)

#endif

#if(TESTCASE == 14)

#endif

#if(TESTCASE == 15)

#endif


#if(TESTCASE == 16)
//Message
const uint8 TestCase16_Message[] = {
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
};

// PublicKey
static const uint8 TestCase16_PublicKey[64] = {0x50, 0xE2, 0x78, 0xAB, 0xBA, 0xB4, 0x5C, 0xA2, 0xE8, 0x13, 0x41, 0x99, 0xE0, 0xED, 0xE0, 0xCA,
                        0xA6, 0x94, 0xD3, 0xDE, 0x26, 0xC9, 0xFC, 0xEF, 0xFC, 0xDF, 0xEE, 0xDC, 0x85, 0x92, 0xCC, 0x9D,
                        0x4E, 0x6E, 0xDE, 0x36, 0x2A, 0x2C, 0x62, 0x47, 0xA1, 0x56, 0x33, 0x63, 0x84, 0xDC, 0x9C, 0x09,
                        0xE3, 0x6B, 0x14, 0xB5, 0x63, 0x9B, 0xEB, 0xDD, 0x1B, 0x99, 0xC9, 0x2A, 0x4E, 0x46, 0x44, 0xCD,};
// PrivateKey
static const uint8 TestCase16_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                        0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase16_MixData[1500] = {0u};
uint32 TestCase16_MessageLen = sizeof(TestCase16_Message);
uint8 TestCase16_MixSignature[64] = {0u};
uint8 TestCase16_SignatureZero[64] = {0u};
uint32 TestCase16_SignatureLen = 0u;
Crypto_VerifyResultType TestCase16_VerifyResult = 1u;
uint8 TestCase16_MessageLenTemp[4] = {0u};
uint8 TestCase16_UserIDLenTemp[4] = {0u};
#endif

#if(TESTCASE == 17)
//Message
const uint8 TestCase17_Message[] = {
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
};

// PublicKey
static const uint8 TestCase17_PublicKey[64] = {0x50, 0xE2, 0x78, 0xAB, 0xBA, 0xB4, 0x5C, 0xA2, 0xE8, 0x13, 0x41, 0x99, 0xE0, 0xED, 0xE0, 0xCA,
                        0xA6, 0x94, 0xD3, 0xDE, 0x26, 0xC9, 0xFC, 0xEF, 0xFC, 0xDF, 0xEE, 0xDC, 0x85, 0x92, 0xCC, 0x9D,
                        0x4E, 0x6E, 0xDE, 0x36, 0x2A, 0x2C, 0x62, 0x47, 0xA1, 0x56, 0x33, 0x63, 0x84, 0xDC, 0x9C, 0x09,
                        0xE3, 0x6B, 0x14, 0xB5, 0x63, 0x9B, 0xEB, 0xDD, 0x1B, 0x99, 0xC9, 0x2A, 0x4E, 0x46, 0x44, 0xCD,};
// PrivateKey
static const uint8 TestCase17_PrivateKey[32] = {0x00u};

// TestGroup1 para
uint8 TestCase17_MixData[1500] = {0u};
uint32 TestCase17_MessageLen = sizeof(TestCase17_Message);
uint8 TestCase17_MixSignature[64] = {0u};
uint8 TestCase17_SignatureZero[64] = {0u};
uint32 TestCase17_SignatureLen = 0u;
Crypto_VerifyResultType TestCase17_VerifyResult = 1u;
uint8 TestCase17_MessageLenTemp[4] = {0u};
uint8 TestCase17_UserIDLenTemp[4] = {0u};
#endif

#if(TESTCASE == 18)
//Message
const uint8 TestCase18_Message[] = {
0x7C, 0x93, 0xAA, 0x2C, 0xB2, 0x89, 0xD3, 0x63, 0x94, 0x53, 0xCE, 0x12, 0x40, 0x8F, 0x81, 0x29,
0x53, 0x33, 0x52, 0x8D, 0x04, 0x81, 0x16, 0x3C, 0x76, 0xC9, 0x2C, 0x2E, 0xD5, 0xA2, 0x8F, 0x48,
0x46, 0xE6, 0x3B, 0xC4, 0x6A, 0x17, 0xAD, 0x1F, 0x89, 0x4D, 0x48, 0xF7, 0x1A, 0xDD, 0x66, 0x1C,
0x00, 0x52, 0x9B, 0x96, 0x1C, 0x6D, 0x86, 0xE7, 0xB4, 0xB0, 0xE6, 0x02, 0x46, 0xF0, 0xD8, 0x14,
0x10, 0x07, 0x62, 0xAC, 0xA1, 0x5F, 0x89, 0xC7, 0x81, 0x26, 0xC5, 0x4A, 0xC7, 0xCB, 0xF7, 0x42,
0x39, 0x1B, 0x65, 0xC7, 0x0C, 0x9D, 0x82, 0x7E, 0xB9, 0x9C, 0x33, 0xAE, 0x14, 0xF6, 0xD2, 0x66,
0x0A, 0x80, 0xD3, 0xCD, 0xB3, 0x72, 0xD1, 0x42, 0xD4, 0xC9, 0xFD, 0x15, 0x8D, 0x77, 0x22, 0xF8,
0x1C, 0x74, 0x41, 0x21, 0x3A, 0xF3, 0x15, 0x9C, 0x53, 0x41, 0x7D, 0x10, 0x69, 0x2F, 0xD6, 0x04,
0x3A, 0x79, 0x2C, 0xA6, 0x6C, 0xBD, 0x01, 0x4A, 0xE0, 0xCE, 0xC7, 0x69, 0x18, 0xF7, 0x74, 0xF4,
0xEB, 0xA7, 0x50, 0xD6, 0x8F, 0x88, 0xD5, 0x41, 0x3D, 0x54, 0xAE, 0x08, 0xC9, 0xB1, 0xA8, 0xF7,
0xD7, 0xA6, 0x1B, 0x9C, 0x59, 0xE1, 0x63, 0xA1, 0x4D, 0x9B, 0xF9, 0x9F, 0x47, 0x20, 0x13, 0xC2,
0xE6, 0xE2, 0xE7, 0x6F, 0xD8, 0x85, 0xB6, 0x82, 0xB1, 0x35, 0xD9, 0x0F, 0x2F, 0x49, 0x45, 0xE9,
0x94, 0x89, 0xAA, 0x80, 0x7F, 0xDD, 0x8D, 0x24, 0x74, 0x5B, 0x26, 0x23, 0xC2, 0x53, 0xBF, 0x55,
0xC3, 0xDE, 0x6A, 0x91, 0xA6, 0x12, 0xA5, 0x97, 0x90, 0x90, 0xEF, 0x7D, 0x80, 0x4D, 0x04, 0x51,
0xEA, 0x5A, 0x2B, 0x1F, 0x23, 0xA3, 0xE9, 0x72, 0x04, 0x24, 0x6F, 0xB3, 0xFE, 0xFE, 0xCB, 0xF1,
0xBC, 0xEF, 0xA4, 0x2F, 0x44, 0x7D, 0xA2, 0x63, 0x28, 0x9C, 0x84, 0x85, 0x6A, 0x3E, 0xD5, 0xDC,
0xBE, 0xBB, 0xEA, 0x1C, 0x9F, 0xF9, 0x86, 0xC0, 0xB4, 0x45, 0x08, 0xEB, 0x8B, 0x04, 0x30, 0x9F,
0x72, 0x28, 0xA8, 0xBE, 0x63, 0xD3, 0x21, 0x2D, 0xAA, 0x17, 0xC7, 0xE8, 0xE2, 0xEE, 0x76, 0x44,
0xC5, 0xF3, 0x1B, 0x7A, 0xCD, 0x7A, 0xF4, 0xE9, 0x8C, 0x03, 0xBA, 0xB7, 0x54, 0xB7, 0xCC, 0x74,
0x26, 0x41, 0xBB, 0xA7, 0x3E, 0x39, 0x7D, 0x3B, 0x82, 0x8B, 0x1C, 0xA2, 0x0C, 0x74, 0x97, 0x27,
0xBD, 0x3B, 0xDC, 0x45, 0xAC, 0xEE, 0xC1, 0x8B, 0x82, 0xD4, 0x76, 0xAA, 0x27, 0xED, 0x36, 0xA6,
0x12, 0x95, 0xAD, 0x91, 0x4E, 0x0A, 0x69, 0xED, 0x24, 0x72, 0x6F, 0xDF, 0x2D, 0xF6, 0x3A, 0x1D,
0x7E, 0xA8, 0x99, 0x75, 0x58, 0xCA, 0x9D, 0xD9, 0xC4, 0x4E, 0x15, 0xF1, 0xF4, 0x0B, 0x50, 0x61,
0xA2, 0x9F, 0xA7, 0xE4, 0x3B, 0xD8, 0x7F, 0x47, 0x06, 0x9D, 0x42, 0x06, 0x75, 0xC8, 0x4B, 0x8C,
0xA5, 0x03, 0x7C, 0x20, 0xBA, 0x17, 0x59, 0xCC, 0x3F, 0x82, 0x24, 0x39, 0x2B, 0x3B, 0xF5, 0x86,
0xBB, 0x42, 0x9A, 0x38, 0x83, 0x0C, 0xB8, 0x19, 0x15, 0x50, 0x31, 0x2A, 0xDB, 0xBF, 0x12, 0xB1,
0x8F, 0x53, 0x7D, 0x3F, 0xC5, 0xF4, 0x0E, 0xF6, 0xF4, 0xD7, 0x2A, 0x2F, 0x42, 0x45, 0xAE, 0x3F,
0x30, 0xF2, 0x65, 0x4E, 0xB4, 0xC5, 0xC6, 0x8F, 0x52, 0x76, 0x12, 0xD9, 0x76, 0xD9, 0x01, 0xB7,
0xBD, 0x8A, 0xEB, 0x5E, 0x8E, 0x90, 0x71, 0xB9, 0x1C, 0x22, 0xA3, 0x03, 0x95, 0x31, 0xA3, 0xBC,
0xE0, 0xFF, 0x1D, 0x8D, 0xF5, 0x55, 0x42, 0xAF, 0x9D, 0x2D, 0x14, 0x75, 0x52, 0xE5, 0x77, 0x1C,
0x38, 0x79, 0xE4, 0x40, 0x7B, 0x0E, 0x86, 0xFD, 0x30, 0x12, 0xBD, 0xFA, 0x72, 0x5E, 0x3B, 0xDD,
0x42, 0x33, 0xF8, 0xEA, 0x2A, 0x91, 0x4D, 0x00, 0x06, 0xDC, 0x93, 0xD8, 0x32, 0xDE, 0x11, 0xC7,
0x06, 0x0E, 0xB2, 0xD9, 0xF9, 0x0C, 0xAE, 0x50, 0x26, 0x72, 0xEF, 0x8E, 0xAC, 0x2A, 0x31, 0xBD,
0x3B, 0x35, 0x94, 0x23, 0x0C, 0xAA, 0x92, 0xDB, 0x6D, 0x00, 0x66, 0xFF, 0xA6, 0xC2, 0xA8, 0xE2,
0x0E, 0xF5, 0x6E, 0x26, 0x95, 0xEE, 0x5B, 0xC0, 0x17, 0xD1, 0x8A, 0x4F, 0x00, 0xA6, 0x8F, 0x4C,
0x26, 0x0B, 0xD6, 0x72, 0xE2, 0xC5, 0xB8, 0xDF, 0x4C, 0xBB, 0x70, 0xC6, 0x4A, 0x5E, 0x03, 0x03,
0x2E, 0x50, 0xAB, 0x9E, 0x99, 0x7A, 0x0F, 0x1F, 0xB0, 0xC4, 0x98, 0x32, 0x8E, 0xA6, 0xE7, 0x85,
0x6A, 0x3F, 0xFB, 0xBA, 0x5F, 0x46, 0x77, 0x45, 0xDB, 0xE1, 0x46, 0x0E, 0xA7, 0x85, 0xC6, 0x1B,
0x4B, 0x07, 0xFE, 0x39, 0xE6, 0x61, 0xA5, 0xB8, 0xF6, 0x2C, 0x14, 0x5E, 0x53, 0x4E, 0xFF, 0x7D,
0x06, 0xCC, 0x34, 0x3A, 0x6D, 0x49, 0xDF, 0x0C, 0xB2, 0x05, 0x7D, 0x41, 0x89, 0x7C, 0x02, 0x4A,
0x1F, 0xBC, 0xA4, 0x85, 0x75, 0x53, 0xED, 0x49, 0x8D, 0xEA, 0xCF, 0x19, 0x23, 0xF0, 0xA2, 0xA8,
0x15, 0x5F, 0xAB, 0x0A, 0xC5, 0xCB, 0x2C, 0x78, 0x37, 0x17, 0x0E, 0x08, 0x71, 0xDF, 0x48, 0x95,
0xC1, 0xD0, 0x03, 0x2D, 0xF7, 0x88, 0x1F, 0x0C, 0x5F, 0x2B, 0xD4, 0x93, 0x22, 0x3F, 0x73, 0xBA,
0x21, 0x46, 0x5F, 0xE3, 0x43, 0x44, 0xFF, 0x70, 0x5C, 0x88, 0xF5, 0xA7, 0xCE, 0x9D, 0x99, 0x7E,
0x21, 0xCD, 0x36, 0x5D, 0x21, 0xBB, 0x59, 0xF5, 0xB6, 0xB8, 0xA8, 0x9C, 0x49, 0xEE, 0x7A, 0x8C,
0x68, 0xA9, 0x3F, 0x43, 0xCD, 0xC6, 0x9C, 0xF7, 0xA9, 0xBC, 0x61, 0xEB, 0x32, 0x25, 0x64, 0x8E,
0x5B, 0x4D, 0x90, 0xAB, 0x13, 0x6D, 0x82, 0x59, 0xD3, 0xB0, 0x60, 0x6F, 0xC0, 0xB4, 0x8F, 0x6A,
0xCC, 0x0F, 0xE2, 0x32, 0x32, 0x3F, 0x21, 0xD1, 0x37, 0xE8, 0xC9, 0x06, 0xBE, 0x5F, 0xDC, 0xC7,
0x34, 0x01, 0xC2, 0x23, 0x4C, 0xC4, 0x95, 0x5E, 0xD9, 0xEA, 0x3D, 0x19, 0x06, 0x60, 0x5D, 0xAC,
0x78, 0x8E, 0xFF, 0x8A, 0x86, 0x49, 0xE8, 0xCE, 0x0B, 0x88, 0x7E, 0x58, 0x16, 0x4D, 0xB6, 0xFF,
0x5C, 0x23, 0xA9, 0x51, 0x77, 0xE6, 0x2D, 0x50, 0x4D, 0x6C, 0x15, 0x8A, 0x3F, 0x39, 0xF4, 0x05,
0x87, 0xA3, 0x17, 0xFD, 0xD6, 0x3E, 0x1D, 0xC6, 0x98, 0x22, 0x2C, 0xA1, 0xCF, 0x59, 0x01, 0xB9,
0xF8, 0xBF, 0xE2, 0xE5, 0xB3, 0x73, 0xDD, 0x2E, 0xBC, 0xCC, 0xA7, 0xFD, 0x8C, 0x1D, 0x58, 0xB9,
0xDF, 0x5B, 0x7D, 0xBE, 0xC2, 0x50, 0x09, 0x81, 0x44, 0xDC, 0xC7, 0x59, 0x56, 0x3F, 0xCA, 0x64,
0x67, 0x4D, 0x75, 0xA6, 0x52, 0x4F, 0x6F, 0x7E, 0x8D, 0xAD, 0x58, 0x70, 0x95, 0x3C, 0x6D, 0xD1,
0x1E, 0x0F, 0xD7, 0x36, 0x80, 0xC8, 0x37, 0x90, 0x8F, 0xF0, 0x7A, 0x95, 0xD8, 0x91, 0xC1, 0x51,
0xD8, 0xF4, 0xF5, 0xC8, 0x4C, 0x26, 0xEC, 0xD6, 0x72, 0xD2, 0xE5, 0xB3, 0x90, 0xE3, 0x35, 0xCB,
0xF2, 0x58, 0x55, 0xC2, 0x3B, 0x15, 0xBC, 0x34, 0x48, 0xBD, 0x91, 0x6E, 0xF2, 0x15, 0x28, 0xA4,
0x57, 0xC3, 0x79, 0x5F, 0x98, 0x5A, 0xF1, 0x86, 0x76, 0x85, 0x09, 0x65, 0x04, 0xC8, 0x7B, 0x60,
0xE7, 0x57, 0x4E, 0x04, 0xA6, 0xE0, 0xE5, 0x46, 0x58, 0x8F, 0x47, 0x1E, 0x3B, 0x77, 0xB2, 0xD4,
0x69, 0x00, 0x30, 0x29, 0x8D, 0x67, 0xFD, 0xEA, 0x7C, 0x52, 0xCE, 0x2F, 0xEC, 0x54, 0xAE, 0xFB,
0x4F, 0xFB, 0x59, 0x81, 0xAB, 0x44, 0xCC, 0xD1, 0x96, 0xC2, 0xE0, 0x19, 0x20, 0x53, 0xFC, 0x6A,
0x01, 0xEB, 0x37, 0x2E, 0x61, 0xFB, 0xA5, 0xEA, 0xE2, 0x6A, 0x4F, 0x2E, 0x32, 0xD2, 0x95, 0xDA,
0xDF, 0x18, 0x9F, 0xED, 0xD1, 0x4A, 0x1F, 0x03, 0xC5, 0x68, 0xB3, 0xD1, 0x2C, 0x09, 0xE9, 0x27,
};

// PublicKey
static const uint8 TestCase18_PublicKey[64] = {0x00u};
// PrivateKey
static const uint8 TestCase18_PrivateKey[32] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                        0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

// TestGroup1 para
uint8 TestCase18_MixData[1500] = {0u};
uint32 TestCase18_MessageLen = sizeof(TestCase18_Message);
uint8 TestCase18_MixSignature[64] = {0x3a, 0x20, 0xe5, 0x91, 0x75, 0x0b, 0x60, 0x96, 0x27, 0xbf, 0x4b, 0x6c, 0xec, 0x56, 0xdf, 0xb3,
                                        0x61, 0x22, 0x85, 0x42, 0x82, 0xc6, 0xbb, 0xee, 0x01, 0xbc, 0x16, 0x20, 0xc6, 0xfa, 0xd2, 0x1c,
                                        0x82, 0x5a, 0x64, 0x47, 0x04, 0x97, 0x9a, 0x76, 0x32, 0x60, 0x16, 0x38, 0xc3, 0xb0, 0x88, 0x1c,
                                        0x8c, 0xf8, 0x16, 0xbc, 0x59, 0x5d, 0x20, 0x74, 0xd1, 0x86, 0xc0, 0x8a, 0x59, 0xf9, 0x7a, 0x2d,};
uint8 TestCase18_SignatureZero[64] = {0u};
uint32 TestCase18_SignatureLen = 0u;
Crypto_VerifyResultType TestCase18_VerifyResult = 1u;
uint8 TestCase18_MessageLenTemp[4] = {0u};
uint8 TestCase18_UserIDLenTemp[4] = {0u};
#endif

#if(TESTCASE == 19)

#endif


//Encrypt/Decrypt Test
#if(TESTCASE == 20)

uint8 TestCase20_PublicKey[] = {0x2E, 0xB5, 0x01, 0x93, 0x34, 0xA2, 0x1A, 0xE6, 0x18, 0x57, 0x00, 0x09, 0x49, 0x1C, 0x50, 0xB3,
                        0xC1, 0x7D, 0x6E, 0x6B, 0x6B, 0x9C, 0xDE, 0xAF, 0x7E, 0x92, 0x4B, 0x50, 0x04, 0x85, 0x22, 0x52,
                        0xCE, 0x93, 0xDF, 0x59, 0xCF, 0xB6, 0x07, 0xB4, 0xED, 0x46, 0xA6, 0x54, 0x34, 0x1F, 0x46, 0x36,
                        0xC1, 0x23, 0x33, 0xC3, 0xFA, 0x13, 0xE2, 0x8F, 0x5B, 0x74, 0x04, 0xA3, 0x0C, 0x0A, 0xFA, 0x84,};
uint8 TestCase20_PrivateKey[] = {0x59, 0xA4, 0x08, 0xB5, 0xED, 0x69, 0xE2, 0xEB, 0xE8, 0xDC, 0x3D, 0xD4, 0x62, 0x14, 0x53, 0xDA,
                        0x8B, 0x0D, 0xEB, 0xF2, 0x94, 0x19, 0x0A, 0xCD, 0x9C, 0xDB, 0x45, 0x2E, 0x90, 0xB7, 0x76, 0x3D,};

const uint8_t TestCase20_PlainMessage[] = {
0x96, 0x63, 0x97, 0xa2, 0x23, 0xd8, 0x52, 0x1d, 0xee, 0xc7, 0xa9, 0xc2, 0x56, 0xba, 0x70, 0xb5,
0x3e, 0x31, 0x3f, 0xb0, 0x56, 0xe9, 0x62, 0xa3, 0x57, 0x38, 0x56, 0x1e, 0xb5, 0xb8, 0xf4, 0xcc,
0x32, 0x2c, 0x24, 0x33, 0xc9, 0xdd, 0xbc, 0xc1, 0xb3, 0xd1, 0x3a, 0x44, 0xa9, 0x79, 0x80, 0x8d,
0xb5, 0xaf, 0xc6, 0xb4, 0x3b, 0xf4, 0x3e, 0x90, 0xfc, 0xa3, 0xce, 0x9f, 0x29, 0x4f, 0xce, 0x82,
};

uint32 TestCase20_PlainMessageLen = sizeof(TestCase20_PlainMessage) ;

uint8 TestCase20_EncryptData[512] = {0u};
uint32 TestCase20_EncryptDataLen = 0u;
uint8 TestCase20_DecryptData[512] = {0u};
uint32 TestCase20_DecryptDataLen = 0u;

#endif

#if(TESTCASE == 21)

uint8 TestCase21_PublicKey[] = {0x2E, 0xB5, 0x01, 0x93, 0x34, 0xA2, 0x1A, 0xE6, 0x18, 0x57, 0x00, 0x09, 0x49, 0x1C, 0x50, 0xB3,
                        0xC1, 0x7D, 0x6E, 0x6B, 0x6B, 0x9C, 0xDE, 0xAF, 0x7E, 0x92, 0x4B, 0x50, 0x04, 0x85, 0x22, 0x52,
                        0xCE, 0x93, 0xDF, 0x59, 0xCF, 0xB6, 0x07, 0xB4, 0xED, 0x46, 0xA6, 0x54, 0x34, 0x1F, 0x46, 0x36,
                        0xC1, 0x23, 0x33, 0xC3, 0xFA, 0x13, 0xE2, 0x8F, 0x5B, 0x74, 0x04, 0xA3, 0x0C, 0x0A, 0xFA, 0x84,};
uint8 TestCase21_PrivateKey[] = {0xBF, 0x72, 0x24, 0x72, 0x6B, 0xCF, 0x10, 0x2D, 0xF8, 0x55, 0x91, 0x52, 0x46, 0xB1, 0x13, 0x65,
                        0x5B, 0x39, 0x76, 0xF4, 0xD2, 0xA4, 0xD8, 0x49, 0x7A, 0x14, 0xAD, 0xD5, 0x0D, 0x82, 0xF2, 0x9C,};

const uint8_t TestCase21_PlainMessage[] = {
0x96, 0x63, 0x97, 0xa2, 0x23, 0xd8, 0x52, 0x1d, 0xee, 0xc7, 0xa9, 0xc2, 0x56, 0xba, 0x70, 0xb5,
0x3e, 0x31, 0x3f, 0xb0, 0x56, 0xe9, 0x62, 0xa3, 0x57, 0x38, 0x56, 0x1e, 0xb5, 0xb8, 0xf4, 0xcc,
0x32, 0x2c, 0x24, 0x33, 0xc9, 0xdd, 0xbc, 0xc1, 0xb3, 0xd1, 0x3a, 0x44, 0xa9, 0x79, 0x80, 0x8d,
0xb5, 0xaf, 0xc6, 0xb4, 0x3b, 0xf4, 0x3e, 0x90, 0xfc, 0xa3, 0xce, 0x9f, 0x29, 0x4f, 0xce, 0x82,
};

uint32 TestCase21_PlainMessageLen = sizeof(TestCase21_PlainMessage) ;

uint8 TestCase21_EncryptData[512] = {0u};
uint32 TestCase21_EncryptDataLen = 0u;
uint8 TestCase21_DecryptData[512] = {0u};
uint32 TestCase21_DecryptDataLen = 0u;

#endif

#if(TESTCASE == 22)

uint8 TestCase22_PublicKey[] = {0x2E, 0xB5, 0x01, 0x93, 0x34, 0xA2, 0x1A, 0xE6, 0x18, 0x57, 0x00, 0x09, 0x49, 0x1C, 0x50, 0xB3,
                        0xC1, 0x7D, 0x6E, 0x6B, 0x6B, 0x9C, 0xDE, 0xAF, 0x7E, 0x92, 0x4B, 0x50, 0x04, 0x85, 0x22, 0x52,
                        0xCE, 0x93, 0xDF, 0x59, 0xCF, 0xB6, 0x07, 0xB4, 0xED, 0x46, 0xA6, 0x54, 0x34, 0x1F, 0x46, 0x36,
                        0xC1, 0x23, 0x33, 0xC3, 0xFA, 0x13, 0xE2, 0x8F, 0x5B, 0x74, 0x04, 0xA3, 0x0C, 0x0A, 0xFA, 0x84,};
uint8 TestCase22_PrivateKey[] = {0x59, 0xA4, 0x08, 0xB5, 0xED, 0x69, 0xE2, 0xEB, 0xE8, 0xDC, 0x3D, 0xD4, 0x62, 0x14, 0x53, 0xDA,
                        0x8B, 0x0D, 0xEB, 0xF2, 0x94, 0x19, 0x0A, 0xCD, 0x9C, 0xDB, 0x45, 0x2E, 0x90, 0xB7, 0x76, 0x3D,};

const uint8_t TestCase22_PlainMessage[] = {
0x96, 0x63, 0x97, 0xa2, 0x23, 0xd8, 0x52, 0x1d, 0xee, 0xc7, 0xa9, 0xc2, 0x56, 0xba, 0x70, 0xb5,
0x3e, 0x31, 0x3f, 0xb0, 0x56, 0xe9, 0x62, 0xa3, 0x57, 0x38, 0x56, 0x1e, 0xb5, 0xb8, 0xf4, 0xcc,
0x32, 0x2c, 0x24, 0x33, 0xc9, 0xdd, 0xbc, 0xc1, 0xb3, 0xd1, 0x3a, 0x44, 0xa9, 0x79, 0x80, 0x8d,
0xb5, 0xaf, 0xc6, 0xb4, 0x3b, 0xf4, 0x3e, 0x90, 0xfc, 0xa3, 0xce, 0x9f, 0x29, 0x4f, 0xce, 0x82,
};

uint32 TestCase22_PlainMessageLen = sizeof(TestCase22_PlainMessage) ;

uint8 TestCase22_EncryptDataA[512] = {0u};
uint32 TestCase22_EncryptDataLenA = 0u;
uint8 TestCase22_EncryptDataB[512] = {0u};
uint32 TestCase22_EncryptDataLenB = 0u;
uint8 TestCase22_DecryptData[512] = {0u};
uint32 TestCase22_DecryptDataLen = 0u;

#endif

#if(TESTCASE == 23)

uint8 TestCase23_PublicKey[] = {0x2E, 0xB5, 0x01, 0x93, 0x34, 0xA2, 0x1A, 0xE6, 0x18, 0x57, 0x00, 0x09, 0x49, 0x1C, 0x50, 0xB3,
                        0xC1, 0x7D, 0x6E, 0x6B, 0x6B, 0x9C, 0xDE, 0xAF, 0x7E, 0x92, 0x4B, 0x50, 0x04, 0x85, 0x22, 0x52,
                        0xCE, 0x93, 0xDF, 0x59, 0xCF, 0xB6, 0x07, 0xB4, 0xED, 0x46, 0xA6, 0x54, 0x34, 0x1F, 0x46, 0x36,
                        0xC1, 0x23, 0x33, 0xC3, 0xFA, 0x13, 0xE2, 0x8F, 0x5B, 0x74, 0x04, 0xA3, 0x0C, 0x0A, 0xFA, 0x84,};
uint8 TestCase23_PrivateKey[] = {0x59, 0xA4, 0x08, 0xB5, 0xED, 0x69, 0xE2, 0xEB, 0xE8, 0xDC, 0x3D, 0xD4, 0x62, 0x14, 0x53, 0xDA,
                        0x8B, 0x0D, 0xEB, 0xF2, 0x94, 0x19, 0x0A, 0xCD, 0x9C, 0xDB, 0x45, 0x2E, 0x90, 0xB7, 0x76, 0x3D,};

const uint8_t TestCase23_PlainMessage[] = {""};

uint32 TestCase23_PlainMessageLen = sizeof(TestCase23_PlainMessage) ;

uint8 TestCase23_EncryptData[512] = {0u};
uint32 TestCase23_EncryptDataLen = 0u;
uint8 TestCase23_DecryptData[512] = {0u};
uint32 TestCase23_DecryptDataLen = 0u;

#endif

#if(TESTCASE == 24)

#endif

#if(TESTCASE == 25)

#endif

#if(TESTCASE == 26)

#endif

#if(TESTCASE == 27)

#endif

#if(TESTCASE == 28)

#endif

#if(TESTCASE == 29)

#endif

#if(TESTCASE == 30)

uint8 TestCase30_PublicKey[] = {0x2E, 0xB5, 0x01, 0x93, 0x34, 0xA2, 0x1A, 0xE6, 0x18, 0x57, 0x00, 0x09, 0x49, 0x1C, 0x50, 0xB3,
                        0xC1, 0x7D, 0x6E, 0x6B, 0x6B, 0x9C, 0xDE, 0xAF, 0x7E, 0x92, 0x4B, 0x50, 0x04, 0x85, 0x22, 0x52,
                        0xCE, 0x93, 0xDF, 0x59, 0xCF, 0xB6, 0x07, 0xB4, 0xED, 0x46, 0xA6, 0x54, 0x34, 0x1F, 0x46, 0x36,
                        0xC1, 0x23, 0x33, 0xC3, 0xFA, 0x13, 0xE2, 0x8F, 0x5B, 0x74, 0x04, 0xA3, 0x0C, 0x0A, 0xFA, 0x84,};
uint8 TestCase30_PrivateKey[] = {0x59, 0xA4, 0x08, 0xB5, 0xED, 0x69, 0xE2, 0xEB, 0xE8, 0xDC, 0x3D, 0xD4, 0x62, 0x14, 0x53, 0xDA,
                        0x8B, 0x0D, 0xEB, 0xF2, 0x94, 0x19, 0x0A, 0xCD, 0x9C, 0xDB, 0x45, 0x2E, 0x90, 0xB7, 0x76, 0x3D,};

const uint8_t TestCase30_PlainMessage[] = {
0x96, 0x63, 0x97, 0xa2, 0x23, 0xd8, 0x52, 0x1d, 0xee, 0xc7, 0xa9, 0xc2, 0x56, 0xba, 0x70, 0xb5,
0x3e, 0x31, 0x3f, 0xb0, 0x56, 0xe9, 0x62, 0xa3, 0x57, 0x38, 0x56, 0x1e, 0xb5, 0xb8, 0xf4, 0xcc,
0x32, 0x2c, 0x24, 0x33, 0xc9, 0xdd, 0xbc, 0xc1, 0xb3, 0xd1, 0x3a, 0x44, 0xa9, 0x79, 0x80, 0x8d,
0xb5, 0xaf, 0xc6, 0xb4, 0x3b, 0xf4, 0x3e, 0x90, 0xfc, 0xa3, 0xce, 0x9f, 0x29, 0x4f, 0xce, 0x82,
};

uint32 TestCase30_PlainMessageLen = sizeof(TestCase30_PlainMessage) ;

uint8 TestCase30_ZeroData[512] = {0u};
uint8 TestCase30_EncryptDataA[512] = {0u};
uint32 TestCase30_EncryptDataLenA = 0u;
uint8 TestCase30_EncryptDataB[512] = {0u};
uint32 TestCase30_EncryptDataLenB = 0u;
uint8 TestCase30_EncryptDataC[512] = {0u};
uint32 TestCase30_EncryptDataLenC = 0u;

uint8 TestCase30_DecryptData[512] = {0u};
uint32 TestCase30_DecryptDataLen = 0u;

uint8 StatusCtl = 0;

#endif

#if(TESTCASE == 31)

#endif

#if(TESTCASE == 32)

uint8 TestCase32_PublicKey[] = {0x2E, 0xB5, 0x01, 0x93, 0x34, 0xA2, 0x1A, 0xE6, 0x18, 0x57, 0x00, 0x09, 0x49, 0x1C, 0x50, 0xB3,
                        0xC1, 0x7D, 0x6E, 0x6B, 0x6B, 0x9C, 0xDE, 0xAF, 0x7E, 0x92, 0x4B, 0x50, 0x04, 0x85, 0x22, 0x52,
                        0xCE, 0x93, 0xDF, 0x59, 0xCF, 0xB6, 0x07, 0xB4, 0xED, 0x46, 0xA6, 0x54, 0x34, 0x1F, 0x46, 0x36,
                        0xC1, 0x23, 0x33, 0xC3, 0xFA, 0x13, 0xE2, 0x8F, 0x5B, 0x74, 0x04, 0xA3, 0x0C, 0x0A, 0xFA, 0x84,};
uint8 TestCase32_PrivateKey[] = {0x59, 0xA4, 0x08, 0xB5, 0xED, 0x69, 0xE2, 0xEB, 0xE8, 0xDC, 0x3D, 0xD4, 0x62, 0x14, 0x53, 0xDA,
                        0x8B, 0x0D, 0xEB, 0xF2, 0x94, 0x19, 0x0A, 0xCD, 0x9C, 0xDB, 0x45, 0x2E, 0x90, 0xB7, 0x76, 0x3D,};

const uint8_t TestCase32_PlainMessage[] = {
0x96, 0x63, 0x97, 0xa2, 0x23, 0xd8, 0x52, 0x1d, 0xee, 0xc7, 0xa9, 0xc2, 0x56, 0xba, 0x70, 0xb5,
0x3e, 0x31, 0x3f, 0xb0, 0x56, 0xe9, 0x62, 0xa3, 0x57, 0x38, 0x56, 0x1e, 0xb5, 0xb8, 0xf4, 0xcc,
0x32, 0x2c, 0x24, 0x33, 0xc9, 0xdd, 0xbc, 0xc1, 0xb3, 0xd1, 0x3a, 0x44, 0xa9, 0x79, 0x80, 0x8d,
0xb5, 0xaf, 0xc6, 0xb4, 0x3b, 0xf4, 0x3e, 0x90, 0xfc, 0xa3, 0xce, 0x9f, 0x29, 0x4f, 0xce, 0x82,
};

uint32 TestCase32_PlainMessageLen = sizeof(TestCase32_PlainMessage) ;

uint8 TestCase32_EncryptData[512] = {0u};
uint32 TestCase32_EncryptDataLen = 0u;
uint8 TestCase32_DecryptData[512] = {0u};
uint32 TestCase32_DecryptDataLen = 0u;

#endif

#if(TESTCASE == 33)

uint8 TestCase33_PublicKey[] = {0x00};
uint8 TestCase33_PrivateKey[] = {0x59, 0xA4, 0x08, 0xB5, 0xED, 0x69, 0xE2, 0xEB, 0xE8, 0xDC, 0x3D, 0xD4, 0x62, 0x14, 0x53, 0xDA,
                        0x8B, 0x0D, 0xEB, 0xF2, 0x94, 0x19, 0x0A, 0xCD, 0x9C, 0xDB, 0x45, 0x2E, 0x90, 0xB7, 0x76, 0x3D,};

const uint8_t TestCase33_PlainMessage[] = {
0x96, 0x63, 0x97, 0xa2, 0x23, 0xd8, 0x52, 0x1d, 0xee, 0xc7, 0xa9, 0xc2, 0x56, 0xba, 0x70, 0xb5,
0x3e, 0x31, 0x3f, 0xb0, 0x56, 0xe9, 0x62, 0xa3, 0x57, 0x38, 0x56, 0x1e, 0xb5, 0xb8, 0xf4, 0xcc,
0x32, 0x2c, 0x24, 0x33, 0xc9, 0xdd, 0xbc, 0xc1, 0xb3, 0xd1, 0x3a, 0x44, 0xa9, 0x79, 0x80, 0x8d,
0xb5, 0xaf, 0xc6, 0xb4, 0x3b, 0xf4, 0x3e, 0x90, 0xfc, 0xa3, 0xce, 0x9f, 0x29, 0x4f, 0xce, 0x82,
};

uint32 TestCase33_PlainMessageLen = sizeof(TestCase33_PlainMessage) ;

uint8 TestCase33_EncryptData[512] = {0u};
uint32 TestCase33_EncryptDataLen = 0u;
uint8 TestCase33_DecryptData[512] = {0u};
uint32 TestCase33_DecryptDataLen = 0u;

#endif

#if(TESTCASE == 34)

uint8 TestCase34_PublicKey[] = {0x2E, 0xB5, 0x01, 0x93, 0x34, 0xA2, 0x1A, 0xE6, 0x18, 0x57, 0x00, 0x09, 0x49, 0x1C, 0x50, 0xB3,
                        0xC1, 0x7D, 0x6E, 0x6B, 0x6B, 0x9C, 0xDE, 0xAF, 0x7E, 0x92, 0x4B, 0x50, 0x04, 0x85, 0x22, 0x52,
                        0xCE, 0x93, 0xDF, 0x59, 0xCF, 0xB6, 0x07, 0xB4, 0xED, 0x46, 0xA6, 0x54, 0x34, 0x1F, 0x46, 0x36,
                        0xC1, 0x23, 0x33, 0xC3, 0xFA, 0x13, 0xE2, 0x8F, 0x5B, 0x74, 0x04, 0xA3, 0x0C, 0x0A, 0xFA, 0x84,};
uint8 TestCase34_PrivateKey[] = {0x00};

const uint8_t TestCase34_PlainMessage[] = {
0x96, 0x63, 0x97, 0xa2, 0x23, 0xd8, 0x52, 0x1d, 0xee, 0xc7, 0xa9, 0xc2, 0x56, 0xba, 0x70, 0xb5,
0x3e, 0x31, 0x3f, 0xb0, 0x56, 0xe9, 0x62, 0xa3, 0x57, 0x38, 0x56, 0x1e, 0xb5, 0xb8, 0xf4, 0xcc,
0x32, 0x2c, 0x24, 0x33, 0xc9, 0xdd, 0xbc, 0xc1, 0xb3, 0xd1, 0x3a, 0x44, 0xa9, 0x79, 0x80, 0x8d,
0xb5, 0xaf, 0xc6, 0xb4, 0x3b, 0xf4, 0x3e, 0x90, 0xfc, 0xa3, 0xce, 0x9f, 0x29, 0x4f, 0xce, 0x82,
};

uint32 TestCase34_PlainMessageLen = sizeof(TestCase34_PlainMessage) ;

uint8 TestCase34_EncryptData[512] = {0u};
uint32 TestCase34_EncryptDataLen = 0u;
uint8 TestCase34_DecryptData[512] = {0u};
uint32 TestCase34_DecryptDataLen = 0u;

#endif

#if(TESTCASE == 35)

uint8 TestCase35_PublicKey[] = {0x2E, 0xB5, 0x01, 0x93, 0x34, 0xA2, 0x1A, 0xE6, 0x18, 0x57, 0x00, 0x09, 0x49, 0x1C, 0x50, 0xB3,
                        0xC1, 0x7D, 0x6E, 0x6B, 0x6B, 0x9C, 0xDE, 0xAF, 0x7E, 0x92, 0x4B, 0x50, 0x04, 0x85, 0x22, 0x52,
                        0xCE, 0x93, 0xDF, 0x59, 0xCF, 0xB6, 0x07, 0xB4, 0xED, 0x46, 0xA6, 0x54, 0x34, 0x1F, 0x46, 0x36,
                        0xC1, 0x23, 0x33, 0xC3, 0xFA, 0x13, 0xE2, 0x8F, 0x5B, 0x74, 0x04, 0xA3, 0x0C, 0x0A, 0xFA, 0x84,};
uint8 TestCase35_PrivateKey[] = {0x59, 0xA4, 0x08, 0xB5, 0xED, 0x69, 0xE2, 0xEB, 0xE8, 0xDC, 0x3D, 0xD4, 0x62, 0x14, 0x53, 0xDA,
                        0x8B, 0x0D, 0xEB, 0xF2, 0x94, 0x19, 0x0A, 0xCD, 0x9C, 0xDB, 0x45, 0x2E, 0x90, 0xB7, 0x76, 0x3D,};

const uint8_t TestCase35_PlainMessage[] = {
0x96, 0x63, 0x97, 0xa2, 0x23, 0xd8, 0x52, 0x1d, 0xee, 0xc7, 0xa9, 0xc2, 0x56, 0xba, 0x70, 0xb5,
0x3e, 0x31, 0x3f, 0xb0, 0x56, 0xe9, 0x62, 0xa3, 0x57, 0x38, 0x56, 0x1e, 0xb5, 0xb8, 0xf4, 0xcc,
0x32, 0x2c, 0x24, 0x33, 0xc9, 0xdd, 0xbc, 0xc1, 0xb3, 0xd1, 0x3a, 0x44, 0xa9, 0x79, 0x80, 0x8d,
0xb5, 0xaf, 0xc6, 0xb4, 0x3b, 0xf4, 0x3e, 0x90, 0xfc, 0xa3, 0xce, 0x9f, 0x29, 0x4f, 0xce, 0x82,
};

uint32 TestCase35_PlainMessageLen = sizeof(TestCase35_PlainMessage) ;

uint8 TestCase35_EncryptData[512] = {0u};
uint32 TestCase35_EncryptDataLen = 0u;
uint8 TestCase35_DecryptData[512] = {0u};
uint32 TestCase35_DecryptDataLen = 0u;

#endif

#if(TESTCASE == 36)

uint8 TestCase36_PublicKey[] = {0x2E, 0xB5, 0x01, 0x93, 0x34, 0xA2, 0x1A, 0xE6, 0x18, 0x57, 0x00, 0x09, 0x49, 0x1C, 0x50, 0xB3,
                        0xC1, 0x7D, 0x6E, 0x6B, 0x6B, 0x9C, 0xDE, 0xAF, 0x7E, 0x92, 0x4B, 0x50, 0x04, 0x85, 0x22, 0x52,
                        0xCE, 0x93, 0xDF, 0x59, 0xCF, 0xB6, 0x07, 0xB4, 0xED, 0x46, 0xA6, 0x54, 0x34, 0x1F, 0x46, 0x36,
                        0xC1, 0x23, 0x33, 0xC3, 0xFA, 0x13, 0xE2, 0x8F, 0x5B, 0x74, 0x04, 0xA3, 0x0C, 0x0A, 0xFA, 0x84,};
uint8 TestCase36_PrivateKey[] = {0x59, 0xA4, 0x08, 0xB5, 0xED, 0x69, 0xE2, 0xEB, 0xE8, 0xDC, 0x3D, 0xD4, 0x62, 0x14, 0x53, 0xDA,
                        0x8B, 0x0D, 0xEB, 0xF2, 0x94, 0x19, 0x0A, 0xCD, 0x9C, 0xDB, 0x45, 0x2E, 0x90, 0xB7, 0x76, 0x3D,};

const uint8_t TestCase36_PlainMessage[] = {
0x96, 0x63, 0x97, 0xa2, 0x23, 0xd8, 0x52, 0x1d, 0xee, 0xc7, 0xa9, 0xc2, 0x56, 0xba, 0x70, 0xb5,
0x3e, 0x31, 0x3f, 0xb0, 0x56, 0xe9, 0x62, 0xa3, 0x57, 0x38, 0x56, 0x1e, 0xb5, 0xb8, 0xf4, 0xcc,
0x32, 0x2c, 0x24, 0x33, 0xc9, 0xdd, 0xbc, 0xc1, 0xb3, 0xd1, 0x3a, 0x44, 0xa9, 0x79, 0x80, 0x8d,
0xb5, 0xaf, 0xc6, 0xb4, 0x3b, 0xf4, 0x3e, 0x90, 0xfc, 0xa3, 0xce, 0x9f, 0x29, 0x4f, 0xce, 0x82,
};

uint32 TestCase36_PlainMessageLen = sizeof(TestCase36_PlainMessage) ;

uint8 TestCase36_EncryptData[512] = {0u};
uint32 TestCase36_EncryptDataLen = 0u;
uint8 TestCase36_DecryptData[512] = {0u};
uint32 TestCase36_DecryptDataLen = 0u;

#endif

#if(TESTCASE == 37)


#endif
/*******************************************************************************
** Global Function Definitions **
*******************************************************************************/
#if(TESTCASE == 1)
//Normal signature verification
//The normal message is signed with a valid private key and verified with a matching public key. The signature is generated successfully. Procedure The verification is successful.
Std_ReturnType TestCase1(void)
{
    Std_ReturnType TestResult;
    
    //Set Message
    UINT32_TO_UINT8_ARRAY(TestCase1_MessageLen,TestCase1_MessageLenTemp);
    memcpy(TestCase1_MixData,TestCase1_MessageLenTemp,sizeof(TestCase1_MessageLenTemp));
    memcpy(&TestCase1_MixData[4],TestCase1_Message,TestCase1_MessageLen);

    // Set UserID
    UINT32_TO_UINT8_ARRAY(User_Len,TestCase1_UserIDLenTemp);
    memcpy(&TestCase1_MixData[TestCase1_MessageLen + 4],TestCase1_UserIDLenTemp,sizeof(TestCase1_UserIDLenTemp));
    memcpy(&TestCase1_MixData[TestCase1_MessageLen + 8],User_Id,User_Len);
    TestResult = Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase1_MixData,(sizeof(TestCase1_Message) + sizeof(User_Id) + 8u),TestCase1_MixSignature,&TestCase1_SignatureLen);

    if ((E_OK == TestResult) && (64u == TestCase1_SignatureLen))
    {
        TestResult = Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase1_MixData,(sizeof(TestCase1_Message) + sizeof(User_Id) + 8u),TestCase1_MixSignature,TestCase1_SignatureLen,&TestCase1_VerifyResult);
    }

    if ((E_OK == TestResult) && (E_OK == TestCase1_VerifyResult))
    {
        /* Test Success */
        TestResult = E_OK;
    }
    else
    {
        /* Test Fail */
        TestResult = E_NOT_OK;
    }
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 2)
//Illegal signature verification
//If the signature is verified with a non-matching public key, the verification failure should generate.
Std_ReturnType TestCase2(void)
{
    Std_ReturnType TestResult;
    
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase2_PublicKey,64);
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase2_PrivateKey,32);
    Csm_KeySetValid(1);

    //Set Message
    UINT32_TO_UINT8_ARRAY(TestCase2_MessageLen,TestCase2_MessageLenTemp);
    memcpy(TestCase2_MixData,TestCase2_MessageLenTemp,sizeof(TestCase2_MessageLenTemp));
    memcpy(&TestCase2_MixData[4],TestCase2_Message,TestCase2_MessageLen);

    // Set UserID
    UINT32_TO_UINT8_ARRAY(User_Len,TestCase2_UserIDLenTemp);
    memcpy(&TestCase2_MixData[TestCase2_MessageLen + 4],TestCase2_UserIDLenTemp,sizeof(TestCase2_UserIDLenTemp));
    memcpy(&TestCase2_MixData[TestCase2_MessageLen + 8],User_Id,User_Len);
    TestResult = Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase2_MixData,(sizeof(TestCase2_Message) + sizeof(User_Id) + 8u),TestCase2_MixSignature,&TestCase2_SignatureLen);

    if ((E_OK == TestResult) && (64u == TestCase2_SignatureLen))
    {
        TestResult = Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase2_MixData,(sizeof(TestCase2_Message) + sizeof(User_Id) + 8u),TestCase2_MixSignature,TestCase2_SignatureLen,&TestCase2_VerifyResult);
    }
    else
    {
        return E_NOT_OK;
    }
    
    if (E_OK != TestCase2_VerifyResult)
    {
        /* Test Success */
        TestResult = E_OK;
    }
    else
    {
        /* Test Fail */
        TestResult = E_NOT_OK;
    }
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 3)
//Illegal message verification
//A message signed with a valid private key is tampered with during transmission. The signature is generated successfully. Procedure The verification failed.
Std_ReturnType TestCase3(void)
{
    Std_ReturnType TestResult;
    
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase3_PublicKey,64);
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase3_PrivateKey,32);
    Csm_KeySetValid(1);

    //Set Message
    UINT32_TO_UINT8_ARRAY(TestCase3_MessageLen,TestCase3_MessageLenTemp);
    memcpy(TestCase3_MixData,TestCase3_MessageLenTemp,sizeof(TestCase3_MessageLenTemp));
    memcpy(&TestCase3_MixData[4],TestCase3_Message,TestCase3_MessageLen);

    // Set UserID
    UINT32_TO_UINT8_ARRAY(User_Len,TestCase3_UserIDLenTemp);
    memcpy(&TestCase3_MixData[TestCase3_MessageLen + 4],TestCase3_UserIDLenTemp,sizeof(TestCase3_UserIDLenTemp));
    memcpy(&TestCase3_MixData[TestCase3_MessageLen + 8],User_Id,User_Len);
    TestResult = Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase3_MixData,(sizeof(TestCase3_Message) + sizeof(User_Id) + 8u),TestCase3_MixSignature,&TestCase3_SignatureLen);

    if ((E_OK == TestResult) && (64u == TestCase3_SignatureLen))
    {
        memset(&TestCase3_MixData[4],0u,16u);
        TestResult = Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase3_MixData,(sizeof(TestCase3_Message) + sizeof(User_Id) + 8u),TestCase3_MixSignature,TestCase3_SignatureLen,&TestCase3_VerifyResult);
    }
    else
    {
        return E_NOT_OK;
    }
    
    if (E_OK != TestCase3_VerifyResult)
    {
        /* Test Success */
        TestResult = E_OK;
    }
    else
    {
        /* Test Fail */
        TestResult = E_NOT_OK;
    }
    
    return TestResult;
    
}
#endif


#if(TESTCASE == 4)
//Signed empty message
//Sign an empty message, verify the correctness of the signature and validation, message: "" (empty string)
Std_ReturnType TestCase4(void)
{
    Std_ReturnType TestResult;
    
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase4_PublicKey,64);
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase4_PrivateKey,32);
    Csm_KeySetValid(1);

    //Set Message
    UINT32_TO_UINT8_ARRAY(TestCase4_MessageLen,TestCase4_MessageLenTemp);
    memcpy(TestCase4_MixData,TestCase4_MessageLenTemp,sizeof(TestCase4_MessageLenTemp));
    memcpy(&TestCase4_MixData[4],TestCase4_Message,TestCase4_MessageLen);

    // Set UserID
    UINT32_TO_UINT8_ARRAY(User_Len,TestCase4_UserIDLenTemp);
    memcpy(&TestCase4_MixData[TestCase4_MessageLen + 4],TestCase4_UserIDLenTemp,sizeof(TestCase4_UserIDLenTemp));
    memcpy(&TestCase4_MixData[TestCase4_MessageLen + 8],User_Id,User_Len);
    TestResult = Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase4_MixData,(sizeof(TestCase4_Message) + sizeof(User_Id) + 8u),TestCase4_MixSignature,&TestCase4_SignatureLen);

    if ((E_OK == TestResult) && (64u == TestCase4_SignatureLen))
    {
        TestResult = Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase4_MixData,(sizeof(TestCase4_Message) + sizeof(User_Id) + 8u),TestCase4_MixSignature,TestCase4_SignatureLen,&TestCase4_VerifyResult);
    }
    else
    {
        return E_NOT_OK;
    }
    
    if (E_OK != TestCase4_VerifyResult)
    {
        /* Test Success */
        TestResult = E_OK;
    }
    else
    {
        /* Test Fail */
        TestResult = E_NOT_OK;
    }
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 5)
//Signed maximum length message
//The maximum length of a signed message is close to or within the maximum range supported by SM2 (for example, 4KB, 64KB).
Std_ReturnType TestCase5(void)
{
    Std_ReturnType TestResult;
    
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase5_PublicKey,64);
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase5_PrivateKey,32);
    Csm_KeySetValid(1);

    //Set Message
    UINT32_TO_UINT8_ARRAY(TestCase5_MessageLen,TestCase5_MessageLenTemp);
    memcpy(TestCase5_MixData,TestCase5_MessageLenTemp,sizeof(TestCase5_MessageLenTemp));
    memcpy(&TestCase5_MixData[4],TestCase5_Message,TestCase5_MessageLen);

    // Set UserID
    UINT32_TO_UINT8_ARRAY(User_Len,TestCase5_UserIDLenTemp);
    memcpy(&TestCase5_MixData[TestCase5_MessageLen + 4],TestCase5_UserIDLenTemp,sizeof(TestCase5_UserIDLenTemp));
    memcpy(&TestCase5_MixData[TestCase5_MessageLen + 8],User_Id,User_Len);
    TestResult = Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase5_MixData,(sizeof(TestCase5_Message) + sizeof(User_Id) + 8u),TestCase5_MixSignature,&TestCase5_SignatureLen);

    if ((E_OK == TestResult) && (64u == TestCase5_SignatureLen))
    {
        TestResult = Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase5_MixData,(sizeof(TestCase5_Message) + sizeof(User_Id) + 8u),TestCase5_MixSignature,TestCase5_SignatureLen,&TestCase5_VerifyResult);
    }
    else
    {
        return E_NOT_OK;
    }
    
    if (E_OK != TestCase5_VerifyResult)
    {
        /* Test Success */
        TestResult = E_OK;
    }
    else
    {
        /* Test Fail */
        TestResult = E_NOT_OK;
    }
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 6)
//Private key disclosure authentication
Std_ReturnType TestCase6(void)
{
    Std_ReturnType TestResult;
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 7)
//Replay attack
Std_ReturnType TestCase7(void)
{
    Std_ReturnType TestResult;
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 8)
//Random number repeated attack
Std_ReturnType TestCase8(void)
{
    Std_ReturnType TestResult;
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 9)
//High concurrency signature testing
//Need To Set Csm Job ASYNC
Std_ReturnType TestCase9(void)
{
    Std_ReturnType TestResult;

    if ( 0u == StatusCtl)
    {
        Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase9_PublicKey,64);
        Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase9_PrivateKey,32);
        Csm_KeySetValid(1);

        //Set Message
        UINT32_TO_UINT8_ARRAY(TestCase9_MessageLen,TestCase9_MessageLenTemp);
        memcpy(TestCase9_MixData,TestCase9_MessageLenTemp,sizeof(TestCase9_MessageLenTemp));
        memcpy(&TestCase9_MixData[4],TestCase9_Message,TestCase9_MessageLen);

        // Set UserID
        UINT32_TO_UINT8_ARRAY(User_Len,TestCase9_UserIDLenTemp);
        memcpy(&TestCase9_MixData[TestCase9_MessageLen + 4],TestCase9_UserIDLenTemp,sizeof(TestCase9_UserIDLenTemp));
        memcpy(&TestCase9_MixData[TestCase9_MessageLen + 8],User_Id,User_Len);

        //Need To Set Csm Job ASYNC
        Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase9_MixData,(sizeof(TestCase9_Message) + sizeof(User_Id) + 8u),TestCase9_MixSignatureA,&TestCase9_SignatureLenA);
        Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase9_MixData,(sizeof(TestCase9_Message) + sizeof(User_Id) + 8u),TestCase9_MixSignatureB,&TestCase9_SignatureLenB);
        Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase9_MixData,(sizeof(TestCase9_Message) + sizeof(User_Id) + 8u),TestCase9_MixSignatureC,&TestCase9_SignatureLenC);
        StatusCtl = 1u;
    }
    else
    {
        if ((memcmp(TestCase9_MixSignatureA,TestCase9_SignatureZero,32) == 0u) || (memcmp(&TestCase9_MixSignatureA[32],TestCase9_SignatureZero,32)== 0u))
        {
            /* wait for signature generate success */
        }
        else
        {
            if ((memcmp(TestCase9_MixSignatureB,TestCase9_SignatureZero,32) == 0u) || (memcmp(&TestCase9_MixSignatureB[32],TestCase9_SignatureZero,32)== 0u))
            {
                /* wait for signature generate success */
            }
            else
            {
                if ((memcmp(TestCase9_MixSignatureC,TestCase9_SignatureZero,32) == 0u) || (memcmp(&TestCase9_MixSignatureC[32],TestCase9_SignatureZero,32)== 0u))
                {
                    /* wait for signature generate success */
                }
                else
                {
                    //Need To Set Break Point Here
                    TestResult = E_OK;
                    StatusCtl = 0u;
                }
            }
        }
    }
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 10)
//High concurrency signature testing
//Need To Set Csm Job ASYNC
Std_ReturnType TestCase10(void)
{
    Std_ReturnType TestResult;

   if ( 0u == StatusCtl)
   {
        Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase10_PublicKey,64);
        Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase10_PrivateKey,32);
        Csm_KeySetValid(1);

        //Set Message
        UINT32_TO_UINT8_ARRAY(TestCase10_MessageLen,TestCase10_MessageLenTemp);
        memcpy(TestCase10_MixData,TestCase10_MessageLenTemp,sizeof(TestCase10_MessageLenTemp));
        memcpy(&TestCase10_MixData[4],TestCase10_Message,TestCase10_MessageLen);

        // Set UserID
        UINT32_TO_UINT8_ARRAY(User_Len,TestCase10_UserIDLenTemp);
        memcpy(&TestCase10_MixData[TestCase10_MessageLen + 4],TestCase10_UserIDLenTemp,sizeof(TestCase10_UserIDLenTemp));
        memcpy(&TestCase10_MixData[TestCase10_MessageLen + 8],User_Id,User_Len);

        //Need To Set Csm Job ASYNC
        Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase10_MixData,(sizeof(TestCase10_Message) + sizeof(User_Id) + 8u),TestCase10_MixSignature,&TestCase10_SignatureLen);
        StatusCtl = 2u;

   }
   else if(1u == StatusCtl)
   {
       Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase10_MixData,(sizeof(TestCase10_MixData) + sizeof(User_Id) + 8u),TestCase10_MixSignature,TestCase10_SignatureLen,&TestCase10_VerifyResultA);
       Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase10_MixData,(sizeof(TestCase10_MixData) + sizeof(User_Id) + 8u),TestCase10_MixSignature,TestCase10_SignatureLen,&TestCase10_VerifyResultB);
       Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase10_MixData,(sizeof(TestCase10_MixData) + sizeof(User_Id) + 8u),TestCase10_MixSignature,TestCase10_SignatureLen,&TestCase10_VerifyResultC);
       StatusCtl = 3u;
   }
   else if(2u == StatusCtl)
   {
       if ((memcmp(TestCase10_MixSignature,TestCase10_SignatureZero,32) == 0u) || (memcmp(&TestCase10_MixSignature[32],TestCase10_SignatureZero,32)== 0u))
       {
           /* wait for signature generate success */
       }
       else
       {
           StatusCtl = 1u;
       }
   }
   else
   {
       if (1u == TestCase10_VerifyResultA)
       {
           /* wait for signature verify success */
       }
       else
       {
            if (1u == TestCase10_VerifyResultB)
            {
                /* wait for signature verify success */
            }
            else
            {
                if (1u == TestCase10_VerifyResultC)
                {
                    /* wait for signature verify success */
                }
                else
                {
                    /* Need To Set Break Point Here */
                    /* init value*/
                    StatusCtl = 0u;
                    TestResult = E_OK;
                    TestCase10_VerifyResultA = 1u;
                    TestCase10_VerifyResultB = 1u;
                    TestCase10_VerifyResultC = 1u;
                    memset(MixSignature1,0u,64u);
                }
            }
       }
   }
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 11)
//High-load signature testing
//Need To Set Csm Job ASYNC
Std_ReturnType TestCase11(void)
{
    Std_ReturnType TestResult;
    
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase11_PublicKey,64);
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase11_PrivateKey,32);
    Csm_KeySetValid(1);
    //Set Message
    UINT32_TO_UINT8_ARRAY(TestCase11_MessageLen,TestCase11_MessageLenTemp);
    memcpy(TestCase11_MixData,TestCase11_MessageLenTemp,sizeof(TestCase11_MessageLenTemp));
    memcpy(&TestCase11_MixData[4],TestCase11_Message,TestCase11_MessageLen);

    // Set UserID
    UINT32_TO_UINT8_ARRAY(User_Len,TestCase11_UserIDLenTemp);
    memcpy(&TestCase11_MixData[TestCase11_MessageLen + 4],TestCase11_UserIDLenTemp,sizeof(TestCase11_UserIDLenTemp));
    memcpy(&TestCase11_MixData[TestCase11_MessageLen + 8],User_Id,User_Len);

    //Need To Set Csm Job ASYNC
    TestResult = Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase11_MixData,(sizeof(TestCase11_Message) + sizeof(User_Id) + 8u),TestCase11_MixSignature,&TestCase11_SignatureLen);

    if ((E_OK == TestResult) && (64u == TestCase11_SignatureLen))
    {
        /* Test Success */
        TestResult = E_OK
    }
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 12)
//High-load Verify testing
//Need To Set Csm Job ASYNC
Std_ReturnType TestCase12(void)
{
    Std_ReturnType TestResult;
    
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase12_PublicKey,64);
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase12_PrivateKey,32);
    Csm_KeySetValid(1);
    //Set Message
    UINT32_TO_UINT8_ARRAY(TestCase12_MessageLen,TestCase12_MessageLenTemp);
    memcpy(TestCase12_MixData,TestCase12_MessageLenTemp,sizeof(TestCase12_MessageLenTemp));
    memcpy(&TestCase12_MixData[4],TestCase12_Message,TestCase12_MessageLen);

    // Set UserID
    UINT32_TO_UINT8_ARRAY(User_Len,TestCase12_UserIDLenTemp);
    memcpy(&TestCase12_MixData[TestCase12_MessageLen + 4],TestCase12_UserIDLenTemp,sizeof(TestCase12_UserIDLenTemp));
    memcpy(&TestCase12_MixData[TestCase12_MessageLen + 8],User_Id,User_Len);

    //Need To Set Csm Job ASYNC
    Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase12_MixData,(sizeof(TestCase12_MixData) + sizeof(User_Id) + 8u),TestCase12_MixSignature,TestCase12_SignatureLen,&TestCase12_VerifyResult);

    if (E_OK == TestCase12_VerifyResult)
    {
        /* Need To Set Break Point Here */
        /* Test Success */
        TestResult = E_OK;
    }
    else
    {
        /* Test Fail */
        TestResult = E_NOT_OK;
    }
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 13)
//Signature verification delay
Std_ReturnType TestCase13(void)
{
    Std_ReturnType TestResult;
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 14)
//Time consuming analysis
Std_ReturnType TestCase14(void)
{
    Std_ReturnType TestResult;
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 15)
//Run tests for a long time
Std_ReturnType TestCase15(void)
{
    Std_ReturnType TestResult;
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 16)
//After the signature is generated, the signature is directly verified without judgment
//Need To Set Csm Job ASYNC
Std_ReturnType TestCase16(void)
{
    Std_ReturnType TestResult;
    
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase16_PublicKey,64);
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase16_PrivateKey,32);
    Csm_KeySetValid(1);
    //Set Message
    UINT32_TO_UINT8_ARRAY(TestCase16_MessageLen,TestCase16_MessageLenTemp);
    memcpy(TestCase16_MixData,TestCase16_MessageLenTemp,sizeof(TestCase16_MessageLenTemp));
    memcpy(&TestCase16_MixData[4],TestCase16_Message,TestCase16_MessageLen);

    // Set UserID
    UINT32_TO_UINT8_ARRAY(User_Len,TestCase16_UserIDLenTemp);
    memcpy(&TestCase16_MixData[TestCase16_MessageLen + 4],TestCase16_UserIDLenTemp,sizeof(TestCase16_UserIDLenTemp));
    memcpy(&TestCase16_MixData[TestCase16_MessageLen + 8],User_Id,User_Len);
    TestResult = Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase16_MixData,(sizeof(TestCase16_Message) + sizeof(User_Id) + 8u),TestCase16_MixSignature,&TestCase16_SignatureLen);
    Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase16_MixData,(sizeof(TestCase16_MixData) + sizeof(User_Id) + 8u),TestCase16_MixSignature,TestCase16_SignatureLen,&TestCase16_VerifyResult);

    if (E_NOT_OK == TestCase16_VerifyResult)
    {
        /* Test Success */
        TestResult = E_OK;
    }
    else
    {
        /* Test Fail */
        TestResult = E_NOT_OK
    }
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 17)
//Invalid private key signature
//Need To Set Csm Job SYNC
Std_ReturnType TestCase17(void)
{
    Std_ReturnType TestResult;
    
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase17_PublicKey,64);
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase17_PrivateKey,32);
    Csm_KeySetValid(1);
    //Set Message
    UINT32_TO_UINT8_ARRAY(TestCase17_MessageLen,TestCase17_MessageLenTemp);
    memcpy(TestCase17_MixData,TestCase17_MessageLenTemp,sizeof(TestCase17_MessageLenTemp));
    memcpy(&TestCase17_MixData[4],TestCase17_Message,TestCase17_MessageLen);

    // Set UserID
    UINT32_TO_UINT8_ARRAY(User_Len,TestCase17_UserIDLenTemp);
    memcpy(&TestCase17_MixData[TestCase17_MessageLen + 4],TestCase17_UserIDLenTemp,sizeof(TestCase17_UserIDLenTemp));
    memcpy(&TestCase17_MixData[TestCase17_MessageLen + 8],User_Id,User_Len);
    TestResult = Csm_SignatureGenerate(1u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase17_MixData,(sizeof(TestCase17_Message) + sizeof(User_Id) + 8u),TestCase17_MixSignature,&TestCase17_SignatureLen);

    if ((E_OK != TestResult) && (64u != TestCase17_SignatureLen))
    {
        /* Test Success */
        TestResult = E_OK
    }
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 18)
//Invalid public key verification
//Need To Set Csm Job SYNC
Std_ReturnType TestCase18(void)
{
    Std_ReturnType TestResult;
    
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPUB_KEY,TestCase18_PublicKey,64);
    Csm_KeyElementSet(1,CRYPTO_KE_SIGNATUREPRI_KEY,TestCase18_PrivateKey,32);
    Csm_KeySetValid(1);
    //Set Message
    UINT32_TO_UINT8_ARRAY(TestCase18_MessageLen,TestCase18_MessageLenTemp);
    memcpy(TestCase18_MixData,TestCase18_MessageLenTemp,sizeof(TestCase18_MessageLenTemp));
    memcpy(&TestCase18_MixData[4],TestCase18_Message,TestCase18_MessageLen);

    // Set UserID
    UINT32_TO_UINT8_ARRAY(User_Len,TestCase18_UserIDLenTemp);
    memcpy(&TestCase18_MixData[TestCase18_MessageLen + 4],TestCase18_UserIDLenTemp,sizeof(TestCase18_UserIDLenTemp));
    memcpy(&TestCase18_MixData[TestCase18_MessageLen + 8],User_Id,User_Len);
    Csm_SignatureVerify(2u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase18_MixData,(sizeof(TestCase18_MixData) + sizeof(User_Id) + 8u),TestCase18_MixSignature,TestCase18_SignatureLen,&TestCase18_VerifyResult);

    if (E_NOT_OK == TestCase18_VerifyResult)
    {
        /* Test Success */
        TestResult = E_OK;
    }
    else
    {
        /* Test Fail */
        TestResult = E_NOT_OK;
    }
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 19)
//National secret standards compatibility test
Std_ReturnType TestCase19(void)
{
    Std_ReturnType TestResult;
    
    
    return TestResult;
    
}
#endif



#if(TESTCASE == 20)
//Normal encryption and decryption test
Std_ReturnType TestCase20(void)
{
    Std_ReturnType TestResult;
    Std_ReturnType encrypt_result;
    Std_ReturnType decrypt_result;

    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPUB_KEY,TestCase20_PublicKey,64);
    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPRI_KEY,TestCase20_PrivateKey,32);
    Csm_KeySetValid(3);
    encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase20_PlainMessage,TestCase20_PlainMessageLen, TestCase20_EncryptData,&TestCase20_EncryptDataLen);

    decrypt_result = Csm_Decrypt(4u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase20_EncryptData,TestCase20_EncryptDataLen, TestCase20_DecryptData,&TestCase20_DecryptDataLen);

    if (memcmp(TestCase20_PlainMessage,TestCase20_DecryptData,TestCase20_PlainMessageLen) == E_OK)
    {
        TestResult = E_OK;
    }
    else
    {
        TestResult = E_NOT_OK;
    }
    
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 21)
//Decryption of different private keys
Std_ReturnType TestCase21(void)
{
    Std_ReturnType TestResult;
    Std_ReturnType encrypt_result;
    Std_ReturnType decrypt_result;

    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPUB_KEY,TestCase21_PublicKey,64);
    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPRI_KEY,TestCase21_PrivateKey,32);
    Csm_KeySetValid(3);
    encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase21_PlainMessage,TestCase21_PlainMessageLen, TestCase21_EncryptData,&TestCase21_EncryptDataLen);

    decrypt_result = Csm_Decrypt(4u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase21_EncryptData,TestCase21_EncryptDataLen, TestCase21_DecryptData,&TestCase21_DecryptDataLen);

    if (memcmp(TestCase21_PlainMessage,TestCase21_DecryptData,TestCase21_PlainMessageLen) == E_OK)
    {
        TestResult = E_OK;
    }
    else
    {
        TestResult = E_NOT_OK;
    }
    
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 22)
//Randomness after encryption
Std_ReturnType TestCase22(void)
{
    Std_ReturnType TestResult;
    Std_ReturnType encrypt_result;
    Std_ReturnType decrypt_result;

    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPUB_KEY,TestCase22_PublicKey,64);
    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPRI_KEY,TestCase22_PrivateKey,32);
    Csm_KeySetValid(3);
    encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase22_PlainMessage,TestCase22_PlainMessageLen, TestCase22_EncryptDataA,&TestCase22_EncryptDataLenA);

    encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase22_PlainMessage,TestCase22_PlainMessageLen, TestCase22_EncryptDataB,&TestCase22_EncryptDataLenB);

    if (memcmp(TestCase22_EncryptDataA,TestCase22_EncryptDataB,TestCase22_PlainMessageLen) != E_OK)
    {
        TestResult = E_OK;
    }
    else
    {
        TestResult = E_NOT_OK;
    }
    
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 23)
//Normal encryption and decryption test
Std_ReturnType TestCase23(void)
{
    Std_ReturnType TestResult;
    Std_ReturnType encrypt_result;
    Std_ReturnType decrypt_result;

    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPUB_KEY,TestCase23_PublicKey,64);
    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPRI_KEY,TestCase23_PrivateKey,32);
    Csm_KeySetValid(3);
    encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase23_PlainMessage,TestCase23_PlainMessageLen, TestCase23_EncryptData,&TestCase23_EncryptDataLen);

    decrypt_result = Csm_Decrypt(4u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase23_EncryptData,TestCase23_EncryptDataLen, TestCase23_DecryptData,&TestCase23_DecryptDataLen);

    if (memcmp(TestCase23_PlainMessage,TestCase23_DecryptData,TestCase23_PlainMessageLen) == E_OK)
    {
        TestResult = E_OK;
    }
    else
    {
        TestResult = E_NOT_OK;
    }
    
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 24)
//Maximum length message encryption and decryption
Std_ReturnType TestCase24(void)
{
    
}
#endif

#if(TESTCASE == 25)
//Replay attack
Std_ReturnType TestCase25(void)
{
    
}
#endif

#if(TESTCASE == 26)
//Man-in-the-middle attack
Std_ReturnType TestCase26(void)
{
    
}
#endif

#if(TESTCASE == 27)
//Random number repeated attack
Std_ReturnType TestCase27(void)
{
    
}
#endif

#if(TESTCASE == 28)
//Private key protection
Std_ReturnType TestCase28(void)
{
    
}
#endif

#if(TESTCASE == 29)
//Single encryption and decryption delay
Std_ReturnType TestCase29(void)
{
    
}
#endif

#if(TESTCASE == 30)
//High concurrency encryption and decryption
//Need To Set Csm Job ASYNC
Std_ReturnType TestCase30(void)
{
    Std_ReturnType TestResult;
    Std_ReturnType encrypt_result;
    Std_ReturnType decrypt_result;

   if ( 0u == StatusCtl)
   {
        Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPUB_KEY,TestCase30_PublicKey,64);
        Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPRI_KEY,TestCase30_PrivateKey,32);
        Csm_KeySetValid(3);
        encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase30_PlainMessage,TestCase30_PlainMessageLen, TestCase30_EncryptDataA,&TestCase30_EncryptDataLenA);

        encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase30_PlainMessage,TestCase30_PlainMessageLen, TestCase30_EncryptDataB,&TestCase30_EncryptDataLenB);

        encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase30_PlainMessage,TestCase30_PlainMessageLen, TestCase30_EncryptDataC,&TestCase30_EncryptDataLenC);

        StatusCtl = 1u;
   }
   else
   {
        if (memcmp(TestCase30_ZeroData,TestCase30_EncryptDataA,TestCase30_PlainMessageLen) == E_OK)
        {
            TestResult = E_NOT_OK;
        }
        else
        {
            if (memcmp(TestCase30_ZeroData,TestCase30_EncryptDataB,TestCase30_PlainMessageLen) == E_OK)
            {
                TestResult = E_NOT_OK;
            }
            else
            {
                if (memcmp(TestCase30_ZeroData,TestCase30_EncryptDataB,TestCase30_PlainMessageLen) == E_OK)
                {
                    TestResult = E_NOT_OK;
                }
                else
                {
                    /* Need To Set Break Point Here */
                    TestResult = E_OK;
                    StatusCtl = 0u;
            }
            }
        }
   }
   
    return TestResult;
    
}
#endif

#if(TESTCASE == 31)
//The encryption and decryption interfaces are periodically invoked in the 1msTask
Std_ReturnType TestCase31(void)
{
    
}
#endif

#if(TESTCASE == 32)
//Decrypt between encryption generation, without judgment
//Need To Set Csm Job ASYNC
Std_ReturnType TestCase32(void)
{
    Std_ReturnType TestResult;
    Std_ReturnType encrypt_result;
    Std_ReturnType decrypt_result;

    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPUB_KEY,TestCase32_PublicKey,64);
    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPRI_KEY,TestCase32_PrivateKey,32);
    Csm_KeySetValid(3);
    encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase32_PlainMessage,TestCase32_PlainMessageLen, TestCase32_EncryptData,&TestCase32_EncryptDataLen);

    decrypt_result = Csm_Decrypt(4u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase32_EncryptData,TestCase32_EncryptDataLen, TestCase32_DecryptData,&TestCase32_DecryptDataLen);

    if (memcmp(TestCase32_PlainMessage,TestCase32_DecryptData,TestCase32_PlainMessageLen) != E_OK)
    {
        TestResult = E_OK;
    }
    else
    {
        TestResult = E_NOT_OK;
    }
    
    
    
    return TestResult;
}
#endif

#if(TESTCASE == 33)
//Illegal public key encryption
Std_ReturnType TestCase33(void)
{
    Std_ReturnType TestResult;
    Std_ReturnType encrypt_result;
    Std_ReturnType decrypt_result;

    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPUB_KEY,TestCase33_PublicKey,64);
    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPRI_KEY,TestCase33_PrivateKey,32);
    Csm_KeySetValid(3);
    encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase33_PlainMessage,TestCase33_PlainMessageLen, TestCase33_EncryptData,&TestCase33_EncryptDataLen);

    if ((encrypt_result == E_NOT_OK || (memcmp(TestCase33_EncryptData,TestCase33_DecryptData,TestCase33_DecryptData) == E_OK)))
    {
        TestResult = E_OK;
    }
    else
    {
        TestResult = E_NOT_OK;
    }
    
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 34)
//Illegal private key decryption
Std_ReturnType TestCase34(void)
{
    Std_ReturnType TestResult;
    Std_ReturnType encrypt_result;
    Std_ReturnType decrypt_result;

    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPUB_KEY,TestCase34_PublicKey,64);
    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPRI_KEY,TestCase34_PrivateKey,32);
    Csm_KeySetValid(3);
    encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase34_PlainMessage,TestCase34_PlainMessageLen, TestCase34_EncryptData,&TestCase34_EncryptDataLen);

    decrypt_result = Csm_Decrypt(4u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase34_EncryptData,TestCase34_EncryptDataLen, TestCase34_DecryptData,&TestCase34_DecryptDataLen);

    if (memcmp(TestCase34_PlainMessage,TestCase34_DecryptData,TestCase34_PlainMessageLen) != E_OK)
    {
        TestResult = E_OK;
    }
    else
    {
        TestResult = E_NOT_OK;
    }
    
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 35)
//Invalid ciphertext decryption
Std_ReturnType TestCase35(void)
{
    Std_ReturnType TestResult;
    Std_ReturnType encrypt_result;
    Std_ReturnType decrypt_result;

    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPUB_KEY,TestCase35_PublicKey,64);
    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPRI_KEY,TestCase35_PrivateKey,32);
    Csm_KeySetValid(3);
    encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase35_PlainMessage,TestCase35_PlainMessageLen, TestCase35_EncryptData,&TestCase35_EncryptDataLen);

    memset(&TestCase35_EncryptData[65],0u,16u);
    decrypt_result = Csm_Decrypt(4u,CRYPTO_OPERATIONMODE_SINGLECALL,TestCase35_EncryptData,TestCase35_EncryptDataLen, TestCase35_DecryptData,&TestCase35_DecryptDataLen);

    if (memcmp(TestCase35_PlainMessage,TestCase35_DecryptData,TestCase35_PlainMessageLen) != E_OK)
    {
        TestResult = E_OK;
    }
    else
    {
        TestResult = E_NOT_OK;
    }
    
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 36)
//Null pointer or invalid input
Std_ReturnType TestCase36(void)
{
    Std_ReturnType TestResult;
    Std_ReturnType encrypt_result;
    Std_ReturnType decrypt_result;

    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPUB_KEY,TestCase36_PublicKey,64);
    Csm_KeyElementSet(3,CRYPTO_KE_CRYPTPRI_KEY,TestCase36_PrivateKey,32);
    Csm_KeySetValid(3);
    encrypt_result = Csm_Encrypt(3u,CRYPTO_OPERATIONMODE_SINGLECALL,NULL_PTR,TestCase36_PlainMessageLen, TestCase36_EncryptData,&TestCase36_EncryptDataLen);

    if (E_NOT_OK == encrypt_result)
    {
        TestResult = E_OK;
    }
    else
    {
        TestResult = E_NOT_OK;
    }
    
    
    
    return TestResult;
    
}
#endif

#if(TESTCASE == 37)
Std_ReturnType TestCase37(void)
{

}
#endif


